package com.gitee.wsl.func.filter.bloomfilter.api

import com.gitee.wsl.base.Objects
import com.gitee.wsl.func.filter.bloomfilter.api.CellExtractor.CellPredicate
import com.gitee.wsl.func.filter.bloomfilter.bean.BitMaps.getLongBit
import com.gitee.wsl.func.filter.bloomfilter.bean.BitMaps.getLongIndex
import com.gitee.wsl.text.format.format

/**
 * The interface that describes a Bloom filter that associates a count with each
 * bit index rather than a bit.  This allows reversal of merge operations with
 * remove operations.
 *
 *
 * A counting Bloom filter is expected to function identically to a standard
 * Bloom filter that is the merge of all the Bloom filters that have been added
 * to and not later subtracted from the counting Bloom filter. The functional
 * state of a CountingBloomFilter at the start and end of a series of merge and
 * subsequent remove operations of the same Bloom filters, irrespective of
 * remove order, is expected to be the same.
 *
 *
 * Removal of a filter that has not previously been merged results in an
 * invalid state where the cells no longer represent a sum of merged Bloom
 * filters. It is impossible to validate merge and remove exactly without
 * explicitly storing all filters. Consequently such an operation may go
 * undetected. The CountingBloomFilter maintains a state flag that is used as a
 * warning that an operation was performed that resulted in invalid cells and
 * thus an invalid state. For example this may occur if a cell for an index was
 * set to negative following a remove operation.
 *
 *
 * Implementations should document the expected state of the filter after an
 * operation that generates invalid cells, and any potential recovery options.
 * An implementation may support a reversal of the operation to restore the
 * state to that prior to the operation. In the event that invalid cells are
 * adjusted to a valid range then it should be documented if there has been
 * irreversible information loss.
 *
 *
 * Implementations may choose to throw an exception during an operation that
 * generates invalid cells. Implementations should document the expected state
 * of the filter after such an operation. For example are the cells not updated,
 * partially updated or updated entirely before the exception is raised.
 *
 * @see CellExtractor
 *
 * @since 4.5.0-M1
 */
interface CountingBloomFilter : BloomFilter<CountingBloomFilter>, CellExtractor {
    // Query Operations
    /**
     * Adds the specified CellExtractor to this Bloom filter.
     *
     *
     * Specifically
     * all cells for the indexes identified by the `other` will be incremented
     * by their corresponding values in the `other`.
     *
     *
     * This method will return `true` if the filter is valid after the operation.
     *
     * @param other the CellExtractor to add.
     * @return `true` if the addition was successful and the state is valid
     * @see .isValid
     * @see .subtract
     */
    fun add(other: CellExtractor): Boolean

    /**
     * Returns the maximum allowable value for a cell count in this Counting filter.
     *
     * @return the maximum allowable value for a cell count in this Counting filter.
     */
    val maxCell: Int

    /**
     * Determines the maximum number of times the BitMapExtractor could have been merged into this counting filter.
     *
     * @param bitMapExtractor the BitMapExtractor to provide the indices.
     * @return the maximum number of times the BitMapExtractor could have been inserted.
     */
    fun getMaxInsert(bitMapExtractor: BitMapExtractor): Int {
        if (!contains(bitMapExtractor)) {
            return 0
        }
        val bitMaps = bitMapExtractor.asBitMapArray()
        val max = intArrayOf(Int.Companion.MAX_VALUE)
        processCells(CellPredicate { x: Int, y: Int ->
            if ((bitMaps[getLongIndex(x)] and getLongBit(x)) != 0L) {
                max[0] = if (max[0] <= y) max[0] else y
            }
            true
        })
        return max[0]
    }

    /**
     * Determines the maximum number of times the Bloom filter could have been merged into this counting filter.
     *
     * @param bloomFilter the Bloom filter the check for.
     * @return the maximum number of times the Bloom filter could have been inserted.
     */
//    fun getMaxInsert(bloomFilter: BloomFilter<*>): Int {
//        return getMaxInsert((bloomFilter as BitMapExtractor)!!)
//    }

    /**
     * Determines the maximum number of times the Cell Extractor could have been added.
     *
     * @param cellExtractor the extractor of cells.
     * @return the maximum number of times the CellExtractor could have been inserted.
     */
    fun getMaxInsert(cellExtractor: CellExtractor): Int

    /**
     * Determines the maximum number of times the Hasher could have been merged into this counting filter.
     *
     * @param hasher the Hasher to provide the indices.
     * @return the maximum number of times the hasher could have been inserted.
     */
    fun getMaxInsert(hasher: Hasher): Int {
        return getMaxInsert(hasher.indices(shape))
    }

    /**
     * Determines the maximum number of times the IndexExtractor could have been merged into this counting filter.
     *
     *
     * To determine how many times an indexExtractor could have been added create a CellExtractor from the indexExtractor and check that
     *
     *
     * @param indexExtractor the extractor to drive the count check.
     * @return the maximum number of times the IndexExtractor could have been inserted.
     * @see .getMaxInsert
     */
    fun getMaxInsert(indexExtractor: IndexExtractor): Int {
        return getMaxInsert(CellExtractor.from(indexExtractor.uniqueIndices()))
    }

    /**
     * Returns `true` if the internal state is valid.
     *
     *
     * This flag is a warning that an addition or
     * subtraction of cells from this filter resulted in an invalid cell for one or more
     * indexes. For example this may occur if a cell for an index was
     * set to negative following a subtraction operation, or overflows the value specified by `getMaxCell()` following an
     * addition operation.
     *
     *
     * A counting Bloom filter that has an invalid state is no longer ensured to function
     * identically to a standard Bloom filter instance that is the merge of all the Bloom filters
     * that have been added to and not later subtracted from this counting Bloom filter.
     *
     *
     * Note: The change to an invalid state may or may not be reversible. Implementations
     * are expected to document their policy on recovery from an addition or removal operation
     * that generated an invalid state.
     *
     * @return `true` if the state is valid
     */
    val isValid: Boolean

    /**
     * Merges the specified BitMap extractor into this Bloom filter.
     *
     *
     * Specifically: all cells for the indexes identified by the `bitMapExtractor` will be incremented by 1.
     *
     *
     * This method will return `true` if the filter is valid after the operation.
     *
     * @param bitMapExtractor the BitMapExtractor
     * @return `true` if the removal was successful and the state is valid
     * @see .isValid
     * @see .add
     */
    override fun merge(bitMapExtractor: BitMapExtractor): Boolean {
        return merge(IndexExtractor.fromBitMapExtractor(bitMapExtractor))
    }

    /**
     * Merges the specified Bloom filter into this Bloom filter.
     *
     *
     * Specifically: all cells for the indexes identified by the `other` filter will be incremented by 1.
     *
     *
     * Note: If the other filter is a counting Bloom filter the other filter's cells are ignored and it is treated as an
     * IndexExtractor.
     *
     *
     * This method will return `true` if the filter is valid after the operation.
     *
     * @param other the other Bloom filter
     * @return `true` if the removal was successful and the state is valid
     * @see .isValid
     * @see .add
     */
    override fun merge(other: BloomFilter<*>): Boolean {
        return merge(other as IndexExtractor)
    }

    /**
     * Merges the specified Hasher into this Bloom filter.
     *
     *
     * Specifically: all cells for the unique indexes identified by the `hasher` will be incremented by 1.
     *
     *
     * This method will return `true` if the filter is valid after the operation.
     *
     * @param hasher the hasher
     * @return `true` if the removal was successful and the state is valid
     * @see .isValid
     * @see .add
     */
    override fun merge(hasher: Hasher): Boolean {
        return merge(hasher.indices(shape))
    }

    /**
     * Merges the specified index extractor into this Bloom filter.
     *
     *
     * Specifically: all unique cells for the indices identified by the `indexExtractor` will be incremented by 1.
     *
     *
     * This method will return `true` if the filter is valid after the operation.
     *
     *
     * Notes:
     *
     *  * If indices that are returned multiple times should be incremented multiple times convert the IndexExtractor
     * to a CellExtractor and add that.
     *  * Implementations should throw `IllegalArgumentException` and no other exception on bad input.
     *
     * @param indexExtractor the IndexExtractor
     * @return `true` if the removal was successful and the state is valid
     * @see .isValid
     * @see .add
     */
    override fun merge(indexExtractor: IndexExtractor): Boolean {
        try {
            return add(CellExtractor.from(indexExtractor.uniqueIndices()))
        } catch (e: IndexOutOfBoundsException) {
            throw IllegalArgumentException(
                String.format("Filter only accepts values in the [0,%d) range", shape.numberOfBits), e
            )
        }
    }

    /**
     * Removes the specified BitMapExtractor from this Bloom filter.
     *
     *
     * Specifically all cells for the indices produced by the `bitMapExtractor` will be
     * decremented by 1.
     *
     *
     * This method will return `true` if the filter is valid after the operation.
     *
     * @param bitMapExtractor the BitMapExtractor to provide the indexes
     * @return `true` if the removal was successful and the state is valid
     * @see .isValid
     * @see .subtract
     */
    fun remove(bitMapExtractor: BitMapExtractor?): Boolean {
        return remove(IndexExtractor.fromBitMapExtractor(bitMapExtractor!!))
    }

    /**
     * Removes the specified Bloom filter from this Bloom filter.
     *
     *
     * Specifically: all cells for the indexes identified by the `other` filter will be decremented by 1.
     *
     *
     * Note: If the other filter is a counting Bloom filter the other filter's cells are ignored and it is treated as an
     * IndexExtractor.
     *
     *
     * This method will return `true` if the filter is valid after the operation.
     *
     * @param other the other Bloom filter
     * @return `true` if the removal was successful and the state is valid
     * @see .isValid
     * @see .subtract
     */
    fun remove(other: BloomFilter<*>): Boolean {
        return remove((other as IndexExtractor))
    }

    /**
     * Removes the unique values from the specified hasher from this Bloom filter.
     *
     *
     * Specifically all cells for the unique indices produced by the `hasher` will be
     * decremented by 1.
     *
     *
     * This method will return `true` if the filter is valid after the operation.
     *
     * @param hasher the hasher to provide the indexes
     * @return `true` if the removal was successful and the state is valid
     * @see .isValid
     * @see .subtract
     */
    fun remove(hasher: Hasher): Boolean {
        return remove(hasher.indices(shape))
    }

    /**
     * Removes the values from the specified IndexExtractor from the Bloom filter from this Bloom filter.
     *
     *
     * Specifically all cells for the unique indices produced by the `hasher` will be
     * decremented by 1.
     *
     *
     * This method will return `true` if the filter is valid after the operation.
     *
     *
     * Note: If indices that are returned multiple times should be decremented multiple times convert the IndexExtractor
     * to a CellExtractor and subtract that.
     *
     * @param indexExtractor the IndexExtractor to provide the indexes
     * @return `true` if the removal was successful and the state is valid
     * @see .isValid
     * @see .subtract
     */
    fun remove(indexExtractor: IndexExtractor): Boolean {
        try {
            return subtract(CellExtractor.from(indexExtractor.uniqueIndices()))
        } catch (e: IndexOutOfBoundsException) {
            throw IllegalArgumentException(
                String.format("Filter only accepts values in the [0,%d) range", shape.numberOfBits)
            )
        }
    }

    /**
     * Adds the specified CellExtractor to this Bloom filter.
     *
     *
     * Specifically
     * all cells for the indexes identified by the `other` will be decremented
     * by their corresponding values in the `other`.
     *
     *
     * This method will return true if the filter is valid after the operation.
     *
     * @param other the CellExtractor to subtract.
     * @return `true` if the subtraction was successful and the state is valid
     * @see .isValid
     * @see .add
     */
    fun subtract(other: CellExtractor): Boolean

    /**
     * The default implementation is a no-op since the counting bloom filter returns an unique IndexExtractor by default.
     * @return this counting Bloom filter.
     */
    override fun uniqueIndices(): IndexExtractor {
        return this
    }
}
